#pragma once

#include "market_data.h"
#include "execution.h"
#include "market_data_types.h"
#include <string>
#include <unordered_map>
#include <memory>
#include <mutex>
#include <atomic>
#include <vector>
#include "market_data_types.h"

namespace hft {

// 使用market_data_types.h中定义的Position
using hft::Position;

// 单个合约的风险限�?
struct ContractRiskLimits {
    double max_position_value; // 最大持仓价�?
    double max_order_size;     // 最大订单规�?
    double max_leverage;       // 最大杠�?
};

// 风险限制
struct RiskLimits {
    double max_position_value; // 全局最大持仓价�?
    double max_drawdown;       // 最大回�?
    double max_daily_loss;     // 最大日亏损
    double max_order_size;     // 全局最大订单规�?
    double max_leverage;       // 全局最大杠�?
    
    // 单个合约的风险限�?
    std::unordered_map<std::string, ContractRiskLimits> contract_limits;
};

// 风险指标
struct RiskMetrics {
    double current_drawdown;   // 当前回撤
    double daily_pnl;          // 日盈�?
    double total_pnl;          // 总盈�?
    double sharpe_ratio;       // 夏普比率
    double max_drawdown;       // 最大回�?
    
    // 按合约的风险指标
    std::unordered_map<std::string, double> contract_pnl;  // 合约盈亏
    std::unordered_map<std::string, double> contract_drawdown;  // 合约回撤
};

/**
 * @brief 风控规则接口类
 * 
 * 所有风控规则都需要继承此基类并实现相应接口
 */
class RiskRule {
public:
    RiskRule() = default;
    virtual ~RiskRule() = default;

    /**
     * @brief 初始化风控规则
     * @param config 配置参数
     * @return 是否初始化成功
     */
    virtual bool init(const std::string& config) = 0;

    /**
     * @brief 检查订单是否违反风控规则
     * @param order 订单信息
     * @return 是否通过风控检查
     */
    virtual bool checkOrder(const hft::Order& order) = 0;

    /**
     * @brief 检查持仓是否违反风控规则
     * @param position 持仓信息
     * @return 是否通过风控检查
     */
    virtual bool checkPosition(const hft::Position& position) = 0;

    /**
     * @brief 获取规则名称
     * @return 规则名称
     */
    virtual std::string getName() const = 0;
};

/**
 * @brief 风控管理器类
 * 
 * 负责管理和执行所有风控规则
 */
class RiskManager {
private:
    static RiskManager* instance_;
    static std::mutex mutex_;
    
    RiskManager() = default;
    ~RiskManager() = default;
    RiskManager(const RiskManager&) = delete;
    RiskManager& operator=(const RiskManager&) = delete;
    
public:
    static RiskManager& getInstance() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!instance_) {
            instance_ = new RiskManager();
        }
        return *instance_;
    }

    /**
     * @brief 初始化风控管理器
     * @param config 配置参数
     * @return 是否初始化成功
     */
    bool init(const std::string& config);

    /**
     * @brief 添加风控规则
     * @param rule 风控规则
     */
    void addRule(std::shared_ptr<RiskRule> rule);

    /**
     * @brief 检查订单是否通过风控
     * @param order 订单信息
     * @return 是否通过风控检查
     */
    bool checkOrder(const hft::Order& order);

    /**
     * @brief 检查持仓是否通过风控
     * @param position 持仓信息
     * @return 是否通过风控检查
     */
    bool checkPosition(const hft::Position& position);

    // 检查价格是否偏?
    bool checkPriceDeviation(const std::string& symbol, double price);

    // 检查成交量是否超限
    bool checkVolumeLimit(const std::string& symbol, int64_t volume);

    // 检查日亏损是否超限
    bool checkDailyLoss(double loss);

    // 检查回撤是否超�?
    bool checkDrawdown(double drawdown);

    // 更新持仓信息
    void updatePosition(const hft::Position& position);

    // 更新账户信息
    void updateAccount(const hft::Account& account);

    // 更新订单信息
    void updateOrder(const hft::Order& order);

    // 更新成交信息
    void updateTrade(const hft::Trade& trade);

    virtual void updatePnL(double pnl) = 0;            // 更新盈亏
    virtual RiskMetrics getRiskMetrics() const = 0;    // 获取风险指标
    virtual void setContractRiskLimits(const std::string& symbol, const ContractRiskLimits& limits) = 0;  // 设置合约风险限制

private:
    std::vector<std::shared_ptr<RiskRule>> rules_;
};

// 默认风险管理器实?
class DefaultRiskManager : public RiskManager {
public:
    DefaultRiskManager(const RiskLimits& limits);
    
    bool checkOrder(const hft::Order& order) override;
    void updatePosition(const hft::Position& position) override;
    void updatePnL(double pnl) override;
    RiskMetrics getRiskMetrics() const override;
    
    void setRiskLimits(const RiskLimits& limits);     // 设置风险限制
    const RiskLimits& getRiskLimits() const { return limits_; }  // 获取风险限制
    
    void setContractRiskLimits(const std::string& symbol, const ContractRiskLimits& limits) override;  // 设置合约风险限制
    
private:
    RiskLimits limits_;                               // 风险限制
    std::unordered_map<std::string, hft::Position> positions_;  // 持仓映射
    RiskMetrics metrics_;                             // 风险指标
    mutable std::mutex mutex_;                        // 互斥�?
    
    bool checkPositionLimit(const hft::Order& order);      // 检查持仓限�?
    bool checkOrderSize(const hft::Order& order);          // 检查订单规�?
    bool checkDrawdown();                             // 检查回�?
    bool checkDailyLoss();                            // 检查日亏损
    void updateMetrics();                             // 更新指标
};

// 持仓管理�?
class PositionManager {
public:
    PositionManager(std::shared_ptr<RiskManager> risk_manager);
    
    void onOrderFilled(const hft::Order& order);           // 处理订单成交
    void onOrderCancelled(const hft::Order& order);        // 处理订单取消
    hft::Position getPosition(const std::string& symbol) const;  // 获取持仓
    double getTotalPnL() const;                       // 获取总盈�?
    
private:
    std::shared_ptr<RiskManager> risk_manager_;       // 风险管理�?
    std::unordered_map<std::string, hft::Position> positions_;  // 持仓映射
    mutable std::mutex mutex_;                        // 互斥�?
    
    void updatePosition(const hft::Order& order);          // 更新持仓
};

} // namespace hft